//! 墨言类型系统层次结构
//!
//! 实现设计理念："道生一，一生二，二生三，三生万物"
//! 所有类型都源于"道"，形成统一的类型层次结构

use std::collections::HashMap;
use std::fmt;

/// 墨言类型系统的根类型 - 道
/// 所有类型的基类，提供统一的接口
#[derive(Debug, Clone, PartialEq)]
pub struct DaoType {
    /// 类型名称
    pub name: String,
    /// 类型描述
    pub description: String,
    /// 父类型（道本身没有父类型）
    pub parent: Option<String>,
    /// 子类型
    pub children: Vec<String>,
}

impl DaoType {
    /// 创建道类型
    pub fn new() -> Self {
        DaoType {
            name: "道".to_string(),
            description: "万物之源，所有类型的根类型".to_string(),
            parent: None,
            children: vec![
                "数".to_string(),
                "文".to_string(),
                "真伪".to_string(),
                "无".to_string(),
                "集".to_string(),
                "辞".to_string(),
                "汇".to_string(),
                "组".to_string(),
                "函".to_string(),
                "物".to_string(),
            ],
        }
    }
}

/// 基础类型定义
#[derive(Debug, Clone, PartialEq)]
pub enum BasicType {
    /// 数字类型 - 统一的数字类型，内部使用f64存储
    Number,
    /// 字符串类型
    String,
    /// 布尔类型
    Boolean,
    /// 空值类型
    Null,
    /// 任意类型
    Any,
}

/// 复合类型定义
#[derive(Debug, Clone, PartialEq)]
pub enum CompositeType {
    /// 列表类型
    List(Box<TypeDefinition>),
    /// 字典类型
    Dict(Box<TypeDefinition>),
    /// 集合类型
    Set(Box<TypeDefinition>),
    /// 元组类型
    Tuple(Vec<TypeDefinition>),
}

/// 函数类型定义
#[derive(Debug, Clone, PartialEq)]
pub struct FunctionType {
    /// 参数类型列表
    pub param_types: Vec<TypeDefinition>,
    /// 返回类型
    pub return_type: Box<TypeDefinition>,
    /// 是否支持闭包
    pub is_closure: bool,
}

/// 对象类型定义
#[derive(Debug, Clone, PartialEq)]
pub struct ObjectType {
    /// 对象名称
    pub name: String,
    /// 字段定义
    pub fields: HashMap<String, TypeDefinition>,
    /// 方法定义
    pub methods: HashMap<String, FunctionType>,
    /// 父对象（继承）
    pub parent: Option<String>,
}

/// 类型定义枚举
#[derive(Debug, Clone, PartialEq)]
pub enum TypeDefinition {
    /// 基础类型
    Basic(BasicType),
    /// 复合类型
    Composite(CompositeType),
    /// 函数类型
    Function(FunctionType),
    /// 对象类型
    Object(ObjectType),
    /// 泛型类型参数
    Generic(String),
    /// 类型别名
    Alias(String),
    /// 未知类型（用于类型推断）
    Unknown,
}

impl TypeDefinition {
    /// 获取类型的中文名称
    pub fn get_chinese_name(&self) -> String {
        match self {
            TypeDefinition::Basic(basic) => match basic {
                BasicType::Number => "数".to_string(),
                BasicType::String => "文".to_string(),
                BasicType::Boolean => "真伪".to_string(),
                BasicType::Null => "无".to_string(),
                BasicType::Any => "任意".to_string(),
            },
            TypeDefinition::Composite(composite) => match composite {
                CompositeType::List(_) => "集".to_string(),
                CompositeType::Dict(_) => "辞".to_string(),
                CompositeType::Set(_) => "汇".to_string(),
                CompositeType::Tuple(_) => "组".to_string(),
            },
            TypeDefinition::Function(_) => "函".to_string(),
            TypeDefinition::Object(obj) => obj.name.clone(),
            TypeDefinition::Generic(name) => name.clone(),
            TypeDefinition::Alias(name) => name.clone(),
            TypeDefinition::Unknown => "未知".to_string(),
        }
    }

    /// 检查是否为基本类型
    pub fn is_basic_type(&self) -> bool {
        matches!(self, TypeDefinition::Basic(_))
    }

    /// 检查是否为复合类型
    pub fn is_composite_type(&self) -> bool {
        matches!(self, TypeDefinition::Composite(_))
    }

    /// 检查是否为函数类型
    pub fn is_function_type(&self) -> bool {
        matches!(self, TypeDefinition::Function(_))
    }

    /// 检查是否为对象类型
    pub fn is_object_type(&self) -> bool {
        matches!(self, TypeDefinition::Object(_))
    }

    /// 检查是否为泛型类型
    pub fn is_generic_type(&self) -> bool {
        matches!(self, TypeDefinition::Generic(_))
    }

    /// 检查是否为类型别名
    pub fn is_alias_type(&self) -> bool {
        matches!(self, TypeDefinition::Alias(_))
    }

    /// 检查是否支持方法调用
    pub fn supports_method_call(&self) -> bool {
        match self {
            TypeDefinition::Basic(_) => true,     // 基本类型都有内置方法
            TypeDefinition::Composite(_) => true, // 复合类型都有内置方法
            TypeDefinition::Object(obj) => !obj.methods.is_empty(), // 对象的方法
            _ => false,
        }
    }
}

impl fmt::Display for TypeDefinition {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.get_chinese_name())
    }
}

/// 类型层次结构管理器
#[derive(Debug, Clone)]
pub struct TypeHierarchy {
    /// 根类型 - 道
    pub dao: DaoType,
    /// 类型定义映射
    pub types: HashMap<String, TypeDefinition>,
    /// 类型继承关系
    pub inheritance: HashMap<String, Vec<String>>,
}

impl TypeHierarchy {
    /// 创建新的类型层次结构
    pub fn new() -> Self {
        let mut hierarchy = TypeHierarchy {
            dao: DaoType::new(),
            types: HashMap::new(),
            inheritance: HashMap::new(),
        };

        // 注册基本类型
        hierarchy.register_basic_types();

        hierarchy
    }

    /// 注册基本类型
    fn register_basic_types(&mut self) {
        // 数字类型
        self.types
            .insert("数".to_string(), TypeDefinition::Basic(BasicType::Number));
        self.inheritance
            .insert("数".to_string(), vec!["道".to_string()]);

        // 字符串类型
        self.types
            .insert("文".to_string(), TypeDefinition::Basic(BasicType::String));
        self.inheritance
            .insert("文".to_string(), vec!["道".to_string()]);

        // 布尔类型
        self.types.insert(
            "真伪".to_string(),
            TypeDefinition::Basic(BasicType::Boolean),
        );
        self.inheritance
            .insert("真伪".to_string(), vec!["道".to_string()]);

        // 空值类型
        self.types
            .insert("无".to_string(), TypeDefinition::Basic(BasicType::Null));
        self.inheritance
            .insert("无".to_string(), vec!["道".to_string()]);

        // 任意类型
        self.types
            .insert("任意".to_string(), TypeDefinition::Basic(BasicType::Any));
        self.inheritance
            .insert("任意".to_string(), vec!["道".to_string()]);

        // 复合类型
        self.types.insert(
            "集".to_string(),
            TypeDefinition::Composite(CompositeType::List(Box::new(TypeDefinition::Unknown))),
        );
        self.inheritance
            .insert("集".to_string(), vec!["道".to_string()]);

        self.types.insert(
            "辞".to_string(),
            TypeDefinition::Composite(CompositeType::Dict(Box::new(TypeDefinition::Unknown))),
        );
        self.inheritance
            .insert("辞".to_string(), vec!["道".to_string()]);

        self.types.insert(
            "汇".to_string(),
            TypeDefinition::Composite(CompositeType::Set(Box::new(TypeDefinition::Unknown))),
        );
        self.inheritance
            .insert("汇".to_string(), vec!["道".to_string()]);

        self.types.insert(
            "组".to_string(),
            TypeDefinition::Composite(CompositeType::Tuple(vec![])),
        );
        self.inheritance
            .insert("组".to_string(), vec!["道".to_string()]);

        // 函数类型
        self.types.insert(
            "函".to_string(),
            TypeDefinition::Function(FunctionType {
                param_types: vec![],
                return_type: Box::new(TypeDefinition::Basic(BasicType::Null)),
                is_closure: false,
            }),
        );
        self.inheritance
            .insert("函".to_string(), vec!["道".to_string()]);

        // 对象类型（默认的空对象）
        self.types.insert(
            "物".to_string(),
            TypeDefinition::Object(ObjectType {
                name: "物".to_string(),
                fields: HashMap::new(),
                methods: HashMap::new(),
                parent: None,
            }),
        );
        self.inheritance
            .insert("物".to_string(), vec!["道".to_string()]);
    }

    /// 注册类型
    pub fn register_type(
        &mut self,
        name: String,
        type_def: TypeDefinition,
        parent: Option<String>,
    ) {
        self.types.insert(name.clone(), type_def);

        if let Some(parent_name) = parent {
            self.inheritance.entry(name).or_default().push(parent_name);
        }
    }

    /// 获取类型定义
    pub fn get_type(&self, name: &str) -> Option<&TypeDefinition> {
        self.types.get(name)
    }

    /// 检查类型是否存在
    pub fn has_type(&self, name: &str) -> bool {
        self.types.contains_key(name)
    }

    /// 获取类型的所有父类型
    pub fn get_parents(&self, type_name: &str) -> Vec<String> {
        let mut parents = Vec::new();
        if let Some(direct_parents) = self.inheritance.get(type_name) {
            parents.extend(direct_parents.clone());
            // 递归获取所有祖先
            for parent in direct_parents {
                parents.extend(self.get_parents(parent));
            }
        }
        parents
    }

    /// 获取类型的所有子类型
    pub fn get_children(&self, type_name: &str) -> Vec<String> {
        let mut children = Vec::new();
        for (child, parents) in &self.inheritance {
            if parents.contains(&type_name.to_string()) {
                children.push(child.clone());
                // 递归获取所有后代
                children.extend(self.get_children(child));
            }
        }
        children
    }

    /// 检查类型是否是另一个类型的子类型
    pub fn is_subtype(&self, subtype: &str, supertype: &str) -> bool {
        if subtype == supertype {
            return true;
        }

        let parents = self.get_parents(subtype);
        parents.contains(&supertype.to_string())
    }

    /// 检查两个类型是否兼容
    pub fn are_types_compatible(&self, type1: &str, type2: &str) -> bool {
        type1 == type2 || self.is_subtype(type1, type2) || self.is_subtype(type2, type1)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_type_hierarchy_creation() {
        let hierarchy = TypeHierarchy::new();

        assert_eq!(hierarchy.dao.name, "道");
        assert!(hierarchy.has_type("数"));
        assert!(hierarchy.has_type("文"));
        assert!(hierarchy.has_type("真伪"));
        assert!(hierarchy.has_type("无"));
        assert!(hierarchy.has_type("集"));
        assert!(hierarchy.has_type("辞"));
        assert!(hierarchy.has_type("汇"));
        assert!(hierarchy.has_type("组"));
        assert!(hierarchy.has_type("函"));
        assert!(hierarchy.has_type("物"));
    }

    #[test]
    fn test_type_inheritance() {
        let hierarchy = TypeHierarchy::new();

        assert!(hierarchy.is_subtype("数", "道"));
        assert!(hierarchy.is_subtype("文", "道"));
        assert!(hierarchy.is_subtype("真伪", "道"));
        assert!(hierarchy.is_subtype("无", "道"));

        // 检查非继承关系
        assert!(!hierarchy.is_subtype("数", "文"));
        assert!(!hierarchy.is_subtype("文", "数"));
    }

    #[test]
    fn test_type_compatibility() {
        let hierarchy = TypeHierarchy::new();

        assert!(hierarchy.are_types_compatible("数", "数"));
        assert!(hierarchy.are_types_compatible("数", "道"));
        assert!(hierarchy.are_types_compatible("道", "数"));

        assert!(!hierarchy.are_types_compatible("数", "文"));
    }

    #[test]
    fn test_get_parents() {
        let hierarchy = TypeHierarchy::new();

        let number_parents = hierarchy.get_parents("数");
        assert!(number_parents.contains(&"道".to_string()));

        let dao_parents = hierarchy.get_parents("道");
        assert!(dao_parents.is_empty());
    }

    #[test]
    fn test_get_children() {
        let hierarchy = TypeHierarchy::new();

        let dao_children = hierarchy.get_children("道");
        assert!(dao_children.contains(&"数".to_string()));
        assert!(dao_children.contains(&"文".to_string()));
        assert!(dao_children.contains(&"真伪".to_string()));
        assert!(dao_children.contains(&"无".to_string()));
        assert!(dao_children.contains(&"集".to_string()));
        assert!(dao_children.contains(&"辞".to_string()));
        assert!(dao_children.contains(&"汇".to_string()));
        assert!(dao_children.contains(&"组".to_string()));
        assert!(dao_children.contains(&"函".to_string()));
        assert!(dao_children.contains(&"物".to_string()));
    }
}
